﻿#include<string.h>


#include <stdio.h>
//#include <string.h> // 用于 strlen
//void* memcpy(void* dest, void* src, size_t size)
//{
//	char* ret = (char*) dest;
//	char* src1 = (char*)src;
//	while (size)
//	{
//		size--;
//		*ret++ = *src1++;
//	}
//
//	return dest;
//}
//
//void* memcpy(void* dest, const void* src, size_t size) {
//	char* d = static_cast<char*>(dest);          // C++ 风格转换
//	const char* s = static_cast<const char*>(src);
//
//	while (size--) {
//		*d++ = *s++;
//	}
//
//	return dest;
//}


void* memove(void* dest, void* src, size_t n)
{
   char* dest1 = (char*)dest;
   char* src1 = (char*)src;

    if (dest == src)
    {
        return src;
    }
    
    //else if (dest > src && ((char*)dest + n) < src)
    else if (dest > src && dest < (char*)src + n)  // 重叠且 dest 在 src 右侧
    {
        while (n--)
        {
            dest1[n - 1] = src1[n - 1];
        }
    }

    else
    {
        int i = 0;
        while (i!=n)
        {
            dest1[i] = src1[i];
            i++;
        }
    }

}


// 测试函数
void test() {
    printf("===== Testing memove =====\n");

    // 测试用例 1：正常字符串拷贝
    char src1[] = "Hello, memove!";
    char dest1[20] = { 0 }; // 初始化为全0
    memove(dest1, src1, strlen(src1) + 1); // +1 包含 '\0'
    printf("[Test 1] Normal copy: dest1 = \"%s\"\n", dest1);

    // 测试用例 2：空数据（size=0）
    char src2[] = "This should not be copied";
    char dest2[10] = "Original";
    memove(dest2, src2, 0); // 拷贝0字节
    printf("[Test 2] Zero size: dest2 remains \"%s\"\n", dest2);

    // 测试用例 3：整型数组拷贝
    int src3[] = { 1, 2, 3, 4, 5 };
    int dest3[5] = { 0 };
    memove(dest3, src3, sizeof(src3));
    printf("[Test 3] Int array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", dest3[i]); // 应输出 1 2 3 4 5
    }
    printf("\n");

    // 测试用例 4：部分拷贝（只拷贝前5字节）
    char src4[] = "PartialCopy";
    char dest4[10] = { 0 };
    memove(dest4, src4, 5); // 只拷贝 "Parti"
    dest4[5] = '\0'; // 手动添加终止符
    printf("[Test 4] Partial copy: dest4 = \"%s\"\n", dest4);
}
//
//int main()
//{
//    test();
//    return 0;
//}

//
//// 你的 memcpy 实现
//void* memcpy(void* dest, void* src, size_t size) {
//    char* ret = (char*)dest;
//    char* src1 = (char*)src;
//    while (size) {
//        size--;
//        *ret++ = *src1++;
//    }
//    return dest;
//}
//
//// 测试函数
//void test() {
//    printf("===== Testing memcpy =====\n");
//
//    // 测试用例 1：正常字符串拷贝
//    char src1[] = "Hello, memcpy!";
//    char dest1[20] = { 0 }; // 初始化为全0
//    memcpy(dest1, src1, strlen(src1) + 1); // +1 包含 '\0'
//    printf("[Test 1] Normal copy: dest1 = \"%s\"\n", dest1);
//
//    // 测试用例 2：空数据（size=0）
//    char src2[] = "This should not be copied";
//    char dest2[10] = "Original";
//    memcpy(dest2, src2, 0); // 拷贝0字节
//    printf("[Test 2] Zero size: dest2 remains \"%s\"\n", dest2);
//
//    // 测试用例 3：整型数组拷贝
//    int src3[] = { 1, 2, 3, 4, 5 };
//    int dest3[5] = { 0 };
//    memcpy(dest3, src3, sizeof(src3));
//    printf("[Test 3] Int array: ");
//    for (int i = 0; i < 5; i++) {
//        printf("%d ", dest3[i]); // 应输出 1 2 3 4 5
//    }
//    printf("\n");
//
//    // 测试用例 4：部分拷贝（只拷贝前5字节）
//    char src4[] = "PartialCopy";
//    char dest4[10] = { 0 };
//    memcpy(dest4, src4, 5); // 只拷贝 "Parti"
//    dest4[5] = '\0'; // 手动添加终止符
//    printf("[Test 4] Partial copy: dest4 = \"%s\"\n", dest4);
//}
//
//int main() {
//    test();
//    return 0;
//}
//
//int main()
//{
//	memcpy();
//	return 0;
//}


//
//char* strstr(const char* haystack, const char* needle) {
//    if (!*needle) return (char*)haystack;  // 空字符串总是匹配
//
//    for (; *haystack; ++haystack) {
//        if (*haystack == *needle) {
//            const char* h = haystack, * n = needle;
//            while (*h && *n && *h == *n) {
//                ++h;
//                ++n;
//            }
//            if (!*n) return (char*)haystack;  // 完全匹配
//        }
//    }
//    return NULL;
//}




char* my_strstr(const char* a1, const char* a2)
{
    if (!*a2) return (char*)a1;

    for (; *a1; a1++)
    {
        if (*a1 == *a2)
        {
            const char* h = a1, * n = a2;
            while (*h && *n && *h == *n)
            {
                h++, n++;
            }
            if (!*n) return (char*)a1;
        }

    }

    return NULL;
}


int main() {
    // 测试用例数组
    struct TestCase {
        const char* haystack;
        const char* needle;
        int expected_pos;  // -1 表示未找到
    } tests[] = {
        {"Hello, world!", "world", 7},    // 正常查找
        {"Hello, world!", "Hello", 0},    // 匹配开头
        {"Hello, world!", "!", 12},       // 匹配结尾
        {"Hello, world!", "o", 4},        // 返回第一个匹配位置
        {"Hello, world!", "abc", -1},     // 不存在的子串
        {"Hello, world!", "", 0},         // 空 needle 返回 haystack
        {"", "world", -1},                // 空 haystack 返回 NULL
        {"aaaaa", "aa", 0},               // 重复字符测试
        {"mississippi", "issi", 1},       // 重叠模式测试
        {"abc", "abcd", -1}               // needle 比 haystack 长

    };

    int num_tests = sizeof(tests) / sizeof(tests[0]);
    int passed = 0;

    printf("===== 开始测试 my_strstr =====\n\n");

    for (int i = 0; i < num_tests; i++) {
        char* result = my_strstr(tests[i].haystack, tests[i].needle);
        int pos = result ? (int)(result - tests[i].haystack) : -1;

        if (pos == tests[i].expected_pos) {
            printf("✅ 测试 %d 通过: haystack=\"%s\", needle=\"%s\" -> pos=%d\n",
                i + 1, tests[i].haystack, tests[i].needle, pos);
            passed++;
        }
        else {
            printf("❌ 测试 %d 失败: haystack=\"%s\", needle=\"%s\" -> 期望 pos=%d, 实际 pos=%d\n",
                i + 1, tests[i].haystack, tests[i].needle, tests[i].expected_pos, pos);
        }
    }

    printf("\n===== 测试结果 =====\n");
    printf("通过: %d / %d (%.1f%%)\n", passed, num_tests, (float)passed / num_tests * 100);

    return passed == num_tests ? 0 : 1;  // 全部通过返回 0，否则返回 1
}






